#ifndef __SERVER_H__
#define __SERVER_H__
#include"room.hpp"
#include"session.hpp"
#include"matcher.hpp"

#define WWWROOT "./wwwroot/"
class gobang_server
{
private:
    void file_handler(wsserver_t::connection_ptr conn){
        //静态页面的资源请求
        //1.获取到请求uri-资源路径，了解客户端请求的页面文件名称
        websocketpp::http::parser::request req=conn->get_request();
        std::string uri =req.get_uri();
        //2.组合出文件的实际路径    相对根目录+uri
        std::string realpath =_web_root+uri;
        //3.如果请求的是个web根目录（域名后面啥也没写，uri就是'/'），把他转成一个登陆界面(根据最后一个字符后面是不是/来判断)
        if(realpath.back()=='/'){
            realpath+="login.html";
        }
        //4.读取文件内容
        Json::Value resp_json;
        std::string body;
        bool ret=file_util::read(realpath,body);
        if(ret==false){
            //如果文件不存在，读取内容失败，返回404
            body+="<html>";
            body+="<head>";
            // body+="<meta charset=\"UTF-8\">";
            body+="<meta charset='UTF-8'>";
            body+="</head>";
            body+="<body>";
            body+="<h1> Not Found </h1>";
            body+="</body>";
            conn->set_status(websocketpp::http::status_code::not_found);
            conn->set_body(body);
            return;
        }
        //5.设置响应正文
        conn->set_body(body);
        conn->set_status(websocketpp::http::status_code::ok);
    }
    void http_resp(bool result,const std::string& reason,websocketpp::http::status_code::value code
    ,wsserver_t::connection_ptr conn){    
        Json::Value resp_json;
        resp_json["result"]=result;
        resp_json["reason"]=reason;
        std::string resp_body;
        json_util::serialize(resp_json,resp_body);
        conn->set_status(code);
        conn->set_body(resp_body);
        conn->append_header("Content-Type","application/json");
    }
    void reg(wsserver_t::connection_ptr conn){
        //用户注册功能请求的处理
        //1.获取请求正文
        std::string req_body=conn->get_request_body();
        //2.对正文进行json反序列化，得到用户名和密码
        Json::Value login_info;
        bool ret=json_util::deserialize(login_info,req_body);
        if(ret==false){
           DLOG("反序列注册信息失败");
           return http_resp(false,"请求的正文格式错误",websocketpp::http::status_code::bad_request,conn);
        }
        //3.进行数据库的用户新增操作，如果有一栏没输入就不能进入下一步，都输入了且数据库没有对应的用户，就新增
        if(login_info["username"].isNull()||login_info["password"].isNull()){
           DLOG("用户名/密码缺失");
           return http_resp(false,"请输入用户名/密码",websocketpp::http::status_code::bad_request,conn);            
        }
        ret=_ut.insert(login_info);
        if(ret==false){
            DLOG("向数据库插入失败");
            return http_resp(false,"用户名已经被占用",websocketpp::http::status_code::bad_request,conn);
        }
        //4.如果能走到这里，那就注册成功了
        http_resp(true,"用户注册成功",websocketpp::http::status_code::ok,conn);
        DLOG("成功在数据库注册");

    }
    void login(wsserver_t::connection_ptr conn){
        //用户登陆功能的请求处理
        //1.获取请求正文
        std::string req_body=conn->get_request_body();
        //2.对正文进行json反序列化，得到用户名和密码
        Json::Value login_info;
        bool ret=json_util::deserialize(login_info,req_body);
        if(ret==false){
           DLOG("反序列登陆信息失败");
           return http_resp(false,"请求的正文格式错误",websocketpp::http::status_code::bad_request,conn);
        }
        //3.校验正文完整性、进行数据库的用户信息验证
        if(login_info["username"].isNull()||login_info["password"].isNull()){
           DLOG("用户名/密码缺失");
           return http_resp(false,"请输入用户名/密码",websocketpp::http::status_code::bad_request,conn); 
        }
        ret=_ut.login(login_info);
        if(ret==false){
            DLOG("登陆失败失败");
            return http_resp(false,"用户名/密码错误",websocketpp::http::status_code::bad_request,conn);
        }
        //4.如果登陆成功，给用户创建一个session
        uint64_t uid=login_info["id"].asInt64();
        session_ptr ssp=_sm.session_create(uid,LOGIN);
        if(ssp.get()==nullptr){
            DLOG("创建会话失败");
            return http_resp(false,"创建会话失败",websocketpp::http::status_code::internal_server_error,conn);
        }
        _sm.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEOUT);
        //5.设置响应头部：Set-Cookie，将session通过cookie返回
        std::string cookie_ssid ="SSID="+std::to_string(ssp->get_ssid());
        conn->append_header("Set-Cookie",cookie_ssid);
         return http_resp(true,"登陆成功",websocketpp::http::status_code::ok,conn);

    }
    /*前面两个是输入的，第三个是输出的*/
    /*Cookie: SSID=XXX; path=/*/
    bool get_cookie_val(const std::string&cookie_str,const std::string& key,std::string& val){
        //1.以;作为分割符，对字符串进行分割，得到各个单个的cookie信息
        std::vector<std::string> cookie_arr;
        string_util::split(cookie_str,";",cookie_arr);
        for(auto& str:cookie_arr){
            //2.对单个cookie字符串，以=为间隔进行分割，得到key和val
            std::vector<std::string> tmp_arr;
            string_util::split(str,"=",tmp_arr);
            if(tmp_arr.size()!=2) continue;
            if(tmp_arr[0]==key){
                val=tmp_arr[1];
                return true;
            }    
        }
        return false;
    }
    void info(wsserver_t::connection_ptr conn){
        //用户信息获取功能的请求处理
        //1.获取请求信息中的Cookie,从Cookie中获取ssid
        std::string cookie_str=conn->get_request_header("Cookie");
        if(cookie_str.empty()){
            //如果没有cookie,返回错误，没有cookie信息，让客户端重新登陆
            DLOG("没有找到对应的cookie");
            return http_resp(false,"找不到对应信息，请重新登陆",websocketpp::http::status_code::bad_request,conn);
        }
        //2.从cookie中取出ssid
        std::string ssid_str;
        bool ret=get_cookie_val(cookie_str,"SSID",ssid_str);
        if(ret==false){//cookie中没有ssid，返回错误：没有ssid信息，让客户端重新登陆
            DLOG("cookie中没有ssid");
            return http_resp(false,"找不到对应信息，请重新登陆",websocketpp::http::status_code::bad_request,conn);
        }
        //3.在session管理中查找对应的会话信息
        session_ptr ssp=_sm.get_session(std::stol(ssid_str));
        if(ssp.get()==nullptr){
            //没有找到session,则认为登陆已经过期，需要重新登陆
            DLOG("找不到对应session,登陆已过期");
            return http_resp(false,"登陆过期，请重新登陆",websocketpp::http::status_code::bad_request,conn);
        }
        //4.从ssid中拿到用户名，然后通过用户名在数据库里取出对应的信息，进行序列化发送给客户端
        uint64_t uid=ssp->get_user();
        Json::Value user_info;
        ret=_ut.select_by_id(uid,user_info);
        if(ret==false){
            //获取用户信息失败，返回错误:找不到用户信息
            DLOG("数据库获取用户信息失败");
            return http_resp(false,"找不到用户信息，请重新登陆",websocketpp::http::status_code::bad_request,conn);
        }
        std::string body;
        json_util::serialize(user_info,body);
        conn->append_header("Content-Type","application/json");
        conn->set_body(body);
        conn->set_status(websocketpp::http::status_code::ok);
        //5.到了这里说明都找到session中信息，并且返回了，刷新session的过期时间
        _sm.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEOUT);
    }
    void http_callback(websocketpp::connection_hdl hdl){
        wsserver_t::connection_ptr conn=_wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req=conn->get_request();
        std::string method =req.get_method();
        std::string uri =req.get_uri();
        if(method=="POST"&&uri=="/reg"){
            return reg(conn);
        }else if(method=="POST"&&uri=="/login"){
            return login(conn);
        }else if(method=="GET"&&uri=="/info"){
            return info(conn);
        }else{
            return file_handler(conn);
        }
       
        //写死获取的文件和方法测试----因为写死，首页有很多渲染文件找不到
        // std::string filename ="register.html";
        // std::string body;
        // std::string pathname=_web_root+filename;
        // file_util::read(pathname,body);
        // //使用websocket里封装好的http通信接口
        // wsserver_t::connection_ptr conn=_wssrv.get_con_from_hdl(hdl);
        // conn->set_status(websocketpp::http::status_code::ok);
        // conn->append_header("Content-Type","text/html");
        // conn->append_header("Content-Length",std::to_string(body.size()));
        // conn->set_body(body);
        
        //让浏览器可以识别到有渲染过的前端页面
        //使用websocket里封装好的http通信接口
        // wsserver_t::connection_ptr conn=_wssrv.get_con_from_hdl(hdl);
        // websocketpp::http::parser::request req=conn->get_request();
        // std::string uri=req.get_uri();
        // std::string method=req.get_method();
        // std::string body;
        // std::string pathname=_web_root+uri;
        // file_util::read(pathname,body);
        // conn->set_status(websocketpp::http::status_code::ok);
        // // conn->append_header("Content-Length",std::to_string(body.size()));
        // //不能加，让浏览器自己去识别吧
        // conn->set_body(body);
        // DLOG("进入登陆页面成功");
    }
    void ws_resp(wsserver_t::connection_ptr conn,Json::Value resp){
        std::string body;
        json_util::serialize(resp,body);
        conn->send(body);
    }
    session_ptr get_session_by_cookie(wsserver_t::connection_ptr conn,Json::Value& err_resp){
        std::string cookie_str=conn->get_request_header("Cookie");
        if(cookie_str.empty()){
            DLOG("没有找到对应的cookie");
            err_resp["optype"]="hall_ready";
            err_resp["reason"]="找不到对应信息，请重新登陆";
            err_resp["result"]=false;
            ws_resp(conn,err_resp);
            return session_ptr();
        }
        std::string ssid_str;
        bool ret=get_cookie_val(cookie_str,"SSID",ssid_str);
        if(ret==false){//cookie中没有ssid，返回错误：没有ssid信息，让客户端重新登陆
            DLOG("cookie中没有ssid");
            err_resp["optype"]="hall_ready";
            err_resp["reason"]="找不到对应信息，请重新登陆";
            err_resp["result"]=false;
            ws_resp(conn,err_resp);
            return session_ptr();
        }
        session_ptr ssp=_sm.get_session(std::stol(ssid_str));
        if(ssp.get()==nullptr){
            DLOG("找不到对应session,登陆已过期");
            err_resp["optype"]="hall_ready";
            err_resp["reason"]="登陆过期，请重新登陆";
            err_resp["result"]=false;
            ws_resp(conn,err_resp);
            return session_ptr();
        }
        return ssp;
    }
    
    void wsopen_game_hall(wsserver_t::connection_ptr conn){
        //游戏大厅长连接建立
        Json::Value err_resp;
        //1. 登陆验证--判断当前客户端是否已登陆成功--获取一下cookie信息看看有没有，如果有就尝试拿到session
        session_ptr ssp=get_session_by_cookie(conn,err_resp);
        if(ssp.get()==nullptr) return;
        //2. 判断当前客户端是否是重复登陆--判断当前这个客户端是否在游戏大厅里或者游戏房间里存在了
        if(_om.is_in_game_hall(ssp->get_user())||_om.is_in_game_room(ssp->get_user())){
            DLOG("玩家重复登陆，拒绝请求");
            err_resp["optype"]="hall_ready";
            err_resp["reason"]="玩家重复登陆";
            err_resp["result"]=false;
            return ws_resp(conn,err_resp);
        }
        //3. 将当前客户端以及连接加入到游戏大厅
        _om.enter_game_hall(ssp->get_user(),conn);
        //4. 给客户端响应
        Json::Value resp_json;
        resp_json["optype"]="hall_ready";
        resp_json["result"]=true;
        ws_resp(conn,resp_json);
        //5. 设置session为永久存在
        _sm.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEFOR);
    }
    void wsopen_game_room(wsserver_t::connection_ptr conn){
        //1.获取当前客户端的session
        Json::Value err_resp;
        session_ptr ssp=get_session_by_cookie(conn,err_resp);
        if(ssp.get()==nullptr) return;
        //2.当前用户是否已经在游戏房间或者游戏大厅中---出现为不正常
        if(_om.is_in_game_hall(ssp->get_user())||_om.is_in_game_room(ssp->get_user())){
            DLOG("玩家重复登陆，拒绝请求");
            err_resp["optype"]="room_ready";
            err_resp["reason"]="玩家重复登陆";
            err_resp["result"]=false;
            return ws_resp(conn,err_resp);
        }
        //3.判断当前用户是否已经创建好了游戏房间
        room_ptr rp=_rm.get_room_by_uid(ssp->get_user());
        if(rp.get()==nullptr){
            DLOG("无房间信息，取消建立连接");
            err_resp["optype"]="room_ready";
            err_resp["reason"]="没有找到玩家的房间信息";
            err_resp["result"]=false;
            return ws_resp(conn,err_resp);
        }
        //4.将当前用户添加到在线用户管理的游戏房间中
        _om.enter_game_room(ssp->get_user(),conn);
        //5.将session重新设置为永久存在
        _sm.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEFOR);
        //6. 进行响应
        Json::Value resp_json;
        resp_json["optype"]="room_ready";
        resp_json["result"]=true;
        resp_json["room_id"]=rp->room_id();
        resp_json["uid"]=ssp->get_user();
        resp_json["white_id"]=rp->get_white_user();
        resp_json["black_id"]=rp->get_black_user();
        ws_resp(conn,resp_json);
    }
    void wsopen_callback(websocketpp::connection_hdl hdl){
        //websocket长连接建立成功之后的处理函数
        wsserver_t::connection_ptr conn=_wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req=conn->get_request();
        std::string uri =req.get_uri();
        if(uri=="/hall"){//前端代码会写明uri
            //建立了游戏大厅的长连接
            return wsopen_game_hall(conn);
        }else if(uri=="/room"){
            //建立了游戏房间的长连接
            return wsopen_game_room(conn);
        }
    }
    void wsclose_game_hall(wsserver_t::connection_ptr conn){
        Json::Value err_resp;
        //1. 登陆验证--判断当前客户端是否已登陆成功--获取一下cookie信息看看有没有
        session_ptr ssp=get_session_by_cookie(conn,err_resp);
        if(ssp.get()==nullptr) return;
        //2.将玩家从游戏大厅中移除
        _om.exit_game_hall(ssp->get_user());
        //3.将session恢复生命周期的管理，设置定时销毁
        _sm.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEOUT);
    }
    void wsclose_game_room(wsserver_t::connection_ptr conn){
        Json::Value err_resp;
        //1. 获取会话信息，识别客户端
        session_ptr ssp=get_session_by_cookie(conn,err_resp);
        if(ssp.get()==nullptr) return;
        //2.将玩家从在线用户管理中移除
        _om.exit_game_room(ssp->get_user());
        //3.恢复session的生命周期管理，设置定时销毁
        _sm.set_session_expire_time(ssp->get_ssid(),SESSION_TIMEOUT);
        //4.将玩家从游戏房间中移除，房间中所有用户退出了就会销毁房间
        _rm.remove_room_user(ssp->get_user());
    }
    void wsclose_callback(websocketpp::connection_hdl hdl){
        //websocket长连接建立成功之后的处理函数
        wsserver_t::connection_ptr conn=_wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req=conn->get_request();
        std::string uri =req.get_uri();
        if(uri=="/hall"){//前端代码会写明uri
            //页面关闭，就关闭游戏大厅的长连接
            return wsclose_game_hall(conn);
        }else if(uri=="/room"){
            //页面关闭，就关游戏房间的长连接
            return wsclose_game_room(conn);
        }
        
    }
    void wsmsg_game_hall(wsserver_t::connection_ptr conn,wsserver_t::message_ptr msg){
        //1.身份验证，验证当前客户端是哪个玩家
        Json::Value resp_json;
        std::string resp_body;
        session_ptr ssp=get_session_by_cookie(conn,resp_json);
        if(ssp.get()==nullptr) return;
        //2.获取请求信息
        std::string req_body=msg->get_payload();
        Json::Value req_json;
        bool ret =json_util::deserialize(req_json,req_body);
        if(ret==false){
            resp_json["result"]=false;
            resp_json["reason"]="请求信息解析失败";
            return ws_resp(conn,resp_json);
        }
        //3.对请求进行处理
        if(!req_json["optype"].isNull()&&req_json["optype"].asString()=="match_start"){
            // 开始对战匹配：通过匹配模块，将用户添加到匹配队列中
            _mm.add(ssp->get_user());
            resp_json["optype"]="match_start";
            resp_json["result"]=true;
            return ws_resp(conn,resp_json);
        }
        else if(!req_json["optype"].isNull()&&req_json["optype"].asString()=="match_stop"){
            //停止对战匹配：通过匹配模块，将用户从匹配队列中移除
            _mm.del(ssp->get_user());
            resp_json["optype"]="match_stop";
            resp_json["result"]=true;
            return ws_resp(conn,resp_json);
        }
        
        resp_json["optype"]="unknown";
        resp_json["result"]=false;
        return ws_resp(conn,resp_json);
    }
    void wsmsg_game_room(wsserver_t::connection_ptr conn,wsserver_t::message_ptr msg){
        //1.获取客户端session，识别客户端身份
        Json::Value resp_json;
        session_ptr ssp=get_session_by_cookie(conn,resp_json);
        if(ssp.get()==nullptr) return;
        //2.获取客户端房间信息
        room_ptr rp=_rm.get_room_by_uid(ssp->get_user());
        if(rp.get()==nullptr){
            DLOG("无房间信息，取消建立连接");
            resp_json["optype"]="unknown";
            resp_json["reason"]="没有找到玩家的房间信息";
            resp_json["result"]=false;
            return ws_resp(conn,resp_json);
        }
        //3.进行消息的反序列化
        std::string req_body=msg->get_payload();
        Json::Value req_json;
        bool ret =json_util::deserialize(req_json,req_body);
        if(ret==false){
            resp_json["optype"]="unknown";
            resp_json["result"]=false;
            resp_json["reason"]="请求信息解析失败";
            return ws_resp(conn,resp_json);
        }
        //4.通过房间模块进行消息请求的处理
        return rp->handler_request(req_json);
    }
    void wsmsg_callback(websocketpp::connection_hdl hdl,wsserver_t::message_ptr msg){
        //websocket长连接建立成功之后的处理函数
        wsserver_t::connection_ptr conn=_wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req=conn->get_request();
        std::string uri =req.get_uri();
        if(uri=="/hall"){//前端代码会写明uri
            //页面关闭，就关闭游戏大厅的长连接
            return wsmsg_game_hall(conn,msg);
        }else if(uri=="/room"){
            //页面关闭，就关游戏房间的长连接
            return wsmsg_game_room(conn,msg);
        }
    }
public:
    gobang_server(const std::string &host, const std::string &usrname,const std::string&password,
    const std::string& dbname,uint16_t port=3306,const std::string& wwwroot=WWWROOT)
    :_ut(host,usrname,password,dbname,port),_rm(&_ut,&_om),
    _sm(&_wssrv),_mm(&_om,&_rm,&_ut),_web_root(wwwroot)
    {
        _wssrv.set_access_channels(websocketpp::log::alevel::none);
        _wssrv.init_asio();
        _wssrv.set_reuse_addr(true);
        _wssrv.set_http_handler(std::bind(&gobang_server::http_callback,this,std::placeholders::_1));
        _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback,this,std::placeholders::_1));
        _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback,this,std::placeholders::_1));
        _wssrv.set_message_handler(std::bind(&gobang_server::wsmsg_callback,this,std::placeholders::_1,std::placeholders::_2));
    }
    ~gobang_server(){}
    void  start(uint16_t port){
        _wssrv.listen(port);
        _wssrv.start_accept();
        _wssrv.run();
    }

private://之前写的都会在这里实现，全都要
    std::string _web_root;//静态资源根目录  ./wwwroot/    /register.html -> ./wwwroot/register.html
    user_table _ut;
    online_manager _om;
    room_manager _rm;
    session_manager _sm;
    matcher _mm;
    wsserver_t _wssrv;
};


#endif